<template>
	<div class="left-tree">
		<el-tree
			:data="data"
			:props="defaultProps"
			@node-click="handleNodeClick"
		></el-tree>
	</div>
</template>

<script>
import axios from 'axios';
import { TOKEN } from '@/const.js';
import { EventBus } from '@/event-bus';
export default {
	name: 'AppLeftTree',
	props: {},

	data() {
		return {
			data: [],
			defaultProps: {
				children: 'children',
				label: 'name'
			},
			waitRefreshAuthCode: '',
			loading: {}
		};
	},

	mounted() {},
	created() {
    /*
    * 监听EventBus上名为notification的事件。
    * 当接收到事件时，会检查传入的消息message是否等于userLogined。
    * 如果是，则从本地存储中获取当前用户信息，并将其赋值给currentLoginedUser属性。
    * 接着调用userLogined方法，并将当前用户信息作为参数传入。*/
		EventBus.$on('notification', message => {
			if (message === 'userLogined') {
				this.currentLoginedUser = localStorage.getItem('currentUser');
				this.userLogined(this.currentLoginedUser);
			}
		});

		this.requestOrglist();
	},

	methods: {
		userLogined(name) {
			console.log("userLogined开始运行");
			if (name && name.length > 0) {
				axios
					.get('/tjDemo/auth/authInfo/' + name)
					.then(response => {
						let code = response.data || '';
            console.log("测试51行的数据",response.data);
						this.refreshAuthListWithCode(code);
					})
					.catch(error => {
						console.error(error);
					});
			} else {
				this.refreshAuthListWithCode(null);
			}
		},
		loadingAction() {
			this.loading = this.$loading({
				lock: true,
				text: '加载中..',
				spinner: 'el-icon-loading',
				background: 'rgba(0, 0, 0, 0.7)'
			});
		},
		requestOrglist() {
			this.loadingAction();
      // 它主要功能是在发起HTTP请求之前，为请求头添加Authorization字段，其值为Bearer加上TOKEN。
      // 这样做的目的是为了在每次请求中自动带上用户认证信息，以便服务器验证请求的合法性。
      // 如果在处理请求时发生错误，该拦截器会将错误信息返回，并阻止请求继续执行。
			axios.interceptors.request.use(
				config => {
					config.headers.Authorization = `Bearer ${TOKEN}`;
					return config;
				},
				error => {
					return Promise.reject(error);
				}
			);
      /*
      * 这段代码使用axios库发送GET请求到'/test/orglist'接口，然后对返回的响应数据进行处理。
      * 首先，将响应数据赋值给data变量，并使用map方法遍历data数组。
      * 在遍历过程中，判断每个元素的root属性，如果存在，则将该元素的id赋值给root.rootID属性，
      * 并将root.children属性设置为空数组。最后，将处理后的数据赋值给this.data，
      * 并调用this.requestAllNode方法传入处理后的数据。如果请求发生错误，则在控制台输出错误信息。
      * */
			axios
				.get('/test/orglist')
				.then(response => {
					let data = response.data;

					data = data.map(m => {
						if (m.root) {m.root.rootID = m.id;}
						m.root.children = [];
            // console.log('测试data5', m)
            // console.log('测试data6', m.root)
            // console.log('测试data7', m.root.children)
            return m.root;
					});
          // console.log('测试data1', data)
          // console.log('测试data2', data[0])
          // console.log('测试data3', data[0].children)
          // console.log('测试data4', data[0].children[0])
					this.data = data;
					this.requestAllNode(data);
				})
				.catch(error => {
					console.error(error);
				});
		},
    /*
    * 该函数用于刷新授权列表，使用传入的code参数更新waitRefreshAuthCode属性的值为code，然后调用requestOrglist方法。
    * */
		refreshAuthListWithCode(code) {
			this.waitRefreshAuthCode = code;
			this.requestOrglist();
		},
    // 需要向后端传输一个orgId
		refreshAuth() {
			if (!this.waitRefreshAuthCode || this.waitRefreshAuthCode.length === 0)
				return;
			// 暂定无授权记录就拥有root权限
			if (this.waitRefreshAuthCode === '无对应授权记录') {
				this.data = [...this.$appData.treeData];
				return;
			}
			console.log('code===', this.waitRefreshAuthCode);
			console.log('this.data===', this.data);

			let targetParent = this.data.find(m => {
				return this.waitRefreshAuthCode.startsWith(m.code);
			});

			let founded = false;
			do {
				let tar = targetParent?.children?.find(t => {
					return this.waitRefreshAuthCode.startsWith(t.code);
				});
				if (!tar && this.waitRefreshAuthCode === targetParent.code) {
					tar = targetParent;
				}
				// console.log('targetParent---targetParent', targetParent);
				// console.log('tar---tar', tar);
				if (tar.code === this.waitRefreshAuthCode) founded = true;
				if (tar) targetParent = tar;
			} while (
				!founded &&
				targetParent &&
				targetParent.children != null &&
				targetParent.children.length > 0
			);
			this.data = [targetParent];
			this.waitRefreshAuthCode = '';
			console.log('targetParent----', targetParent);
		},
		handleNodeClick(data) {
			if (data && data.users && data.users.length > 0) {
				console.log('data--', data);
				this.$emit('userData', data.users);
			}
		},
		requestAllNode(data) {
			let promises = [];
			data.forEach(element => {
				promises.push(this.requestUnitAllOrg(element.rootID, element.id));
			});
			axios
				.all(promises)
				.then(results => {
					results.forEach(element => {
						if (
							element.data == null ||
							element.data.id == null ||
							element.data.children == null
						)
							return;
						let targetIndex = this.data.findIndex(m => {
							return element.data.code === m.code;
						});

						this.$set(this.data[targetIndex], 'children', [
							...element.data.children
						]);
					});
					this.$appData.treeData = [...this.data];
					this.refreshAuth();
					this.loading.close();
					this.loading = null;
				})
				.catch(errors => {
					// 至少有一个请求失败
					console.error('请求中出现错误', errors);
				});
		},
		requestUnitAllOrg(provideID, id) {
			return axios.get(`/test/tree/${provideID}/${id}/users`);
		}
	}
};
</script>

<style lang="scss" scoped>
.left-tree {
	width: 100%;
	height: 100%;
	overflow: scroll;
	// background-color: rgb(235, 228, 217);
	border: 1px solid rgb(227, 224, 224);
	background-color: rgb(235, 238, 242);
	.el-tree {
		background: rgb(235, 238, 242) !important;
	}
	.el-tree .el-tree-node.is-current {
		color: #000;
		background: transparent;
	}

	display: flex;
	// justify-content: center;
	// align-items: center;
}
</style>
